<!DOCTYPE html>
<html lang="zh-cn">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    
    <title>Pony 教程  | 概述（Overview）</title>
    <meta name="HandheldFriendly" content="True">
    <meta name="MobileOptimized" content="320">

    <meta name="viewport" content="width=device-width,minimum-scale=1">
    <meta name="generator" content="Hugo 0.69.0-DEV" />
    
    
      <META NAME="ROBOTS" CONTENT="NOINDEX, NOFOLLOW">
    

    <style>
      @font-face {
        font-family: 'Icon';
        src: url('/pony-tutorial/dist/fonts/icon.eot?52m981');
        src: url('/pony-tutorial/dist/fonts/icon.eot?#iefix52m981')
               format('embedded-opentype'),
             url('/pony-tutorial/dist/fonts/icon.woff?52m981')
               format('woff'),
             url('/pony-tutorial/dist/fonts/icon.ttf?52m981')
               format('truetype'),
             url('/pony-tutorial/dist/fonts/icon.svg?52m981#icon')
               format('svg');
        font-weight: normal;
        font-style: normal;
      }
    </style>

    <link href="/pony-tutorial/dist/css/app.css" rel="stylesheet">
    <link href="/pony-tutorial/dist/css/highlight.css" rel="stylesheet">
    <link href="/pony-tutorial/dist/css/icon.css" rel="stylesheet">
    <link href="/pony-tutorial/dist/css/pony.css" rel="stylesheet">

    

    
      
    

    
      <link href="https://damon-kwok.github.io/pony-tutorial/expressions/index.xml" rel="alternate" type="application/rss+xml" title="Pony 教程" />
      <link href="https://damon-kwok.github.io/pony-tutorial/expressions/index.xml" rel="feed" type="application/rss+xml" title="Pony 教程" />
    

    <meta property="og:title" content="概述（Overview）" />
<meta property="og:description" content="" />
<meta property="og:type" content="website" />
<meta property="og:url" content="https://damon-kwok.github.io/pony-tutorial/expressions.html" />

<meta itemprop="name" content="概述（Overview）">
<meta itemprop="description" content=""><meta name="twitter:card" content="summary"/>
<meta name="twitter:title" content="概述（Overview）"/>
<meta name="twitter:description" content=""/>

  </head>

  <body class="ma0 avenir bg-near-white">

    

  <header>
    <div class="bg-pony-brown">
      <nav class="pv3 ph3 ph4-ns" role="navigation">
  <div class="flex-l justify-between items-center center">
    <a href="https://damon-kwok.github.io/pony-tutorial/" class="f3 fw2 hover-white no-underline white-90 dib">
      Pony 教程
    </a>
    <div class="flex-l items-center">
      
      
<div hidden>
  <span id="new-window-0">Opens in a new window</span>
  <span id="new-window-1">Opens an external site</span>
  <span id="new-window-2">Opens an external site in a new window</span>
</div>



<a href="https://www.twitter.com/ponylang" target="_blank" class="link-transition twitter link dib z-999 pt3 pt0-l mr1" title="Twitter link" rel="noopener" aria-describedby="new-window-0">
  <svg height="32px"  style="enable-background:new 0 0 67 67;" version="1.1" viewBox="0 0 67 67" width="32px" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><path d="M37.167,22.283c-2.619,0.953-4.274,3.411-4.086,6.101  l0.063,1.038l-1.048-0.127c-3.813-0.487-7.145-2.139-9.974-4.915l-1.383-1.377l-0.356,1.017c-0.754,2.267-0.272,4.661,1.299,6.271  c0.838,0.89,0.649,1.017-0.796,0.487c-0.503-0.169-0.943-0.296-0.985-0.233c-0.146,0.149,0.356,2.076,0.754,2.839  c0.545,1.06,1.655,2.097,2.871,2.712l1.027,0.487l-1.215,0.021c-1.173,0-1.215,0.021-1.089,0.467  c0.419,1.377,2.074,2.839,3.918,3.475l1.299,0.444l-1.131,0.678c-1.676,0.976-3.646,1.526-5.616,1.568  C19.775,43.256,19,43.341,19,43.405c0,0.211,2.557,1.397,4.044,1.864c4.463,1.377,9.765,0.783,13.746-1.568  c2.829-1.673,5.657-5,6.978-8.221c0.713-1.716,1.425-4.851,1.425-6.354c0-0.975,0.063-1.102,1.236-2.267  c0.692-0.678,1.341-1.419,1.467-1.631c0.21-0.403,0.188-0.403-0.88-0.043c-1.781,0.636-2.033,0.551-1.152-0.402  c0.649-0.678,1.425-1.907,1.425-2.267c0-0.063-0.314,0.042-0.671,0.233c-0.377,0.212-1.215,0.53-1.844,0.72l-1.131,0.361l-1.027-0.7  c-0.566-0.381-1.361-0.805-1.781-0.932C39.766,21.902,38.131,21.944,37.167,22.283z M33,64C16.432,64,3,50.569,3,34S16.432,4,33,4  s30,13.431,30,30S49.568,64,33,64z" style="fill-rule:evenodd;clip-rule:evenodd;fill:;"/></svg>

<span class="new-window"><svg  height="8px"  style="enable-background:new 0 0 1000 1000;" version="1.1" viewBox="0 0 1000 1000" width="8px" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" >
<path d="M598 128h298v298h-86v-152l-418 418-60-60 418-418h-152v-86zM810 810v-298h86v298c0 46-40 86-86 86h-596c-48 0-86-40-86-86v-596c0-46 38-86 86-86h298v86h-298v596h596z" style="fill-rule:evenodd;clip-rule:evenodd;fill:;"/>
</svg>
</span></a>





<a href="https://github.com/damon-kwok/pony-tutorial-zh_CN" target="_blank" class="link-transition github link dib z-999 pt3 pt0-l mr1" title="Github link" rel="noopener" aria-describedby="new-window-0">
  <svg  height="32px"  style="enable-background:new 0 0 512 512;" version="1.1" viewBox="0 0 512 512" width="32px" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" >
  <path d="M256,32C132.3,32,32,134.8,32,261.7c0,101.5,64.2,187.5,153.2,217.9c11.2,2.1,15.3-5,15.3-11.1   c0-5.5-0.2-19.9-0.3-39.1c-62.3,13.9-75.5-30.8-75.5-30.8c-10.2-26.5-24.9-33.6-24.9-33.6c-20.3-14.3,1.5-14,1.5-14   c22.5,1.6,34.3,23.7,34.3,23.7c20,35.1,52.4,25,65.2,19.1c2-14.8,7.8-25,14.2-30.7c-49.7-5.8-102-25.5-102-113.5   c0-25.1,8.7-45.6,23-61.6c-2.3-5.8-10-29.2,2.2-60.8c0,0,18.8-6.2,61.6,23.5c17.9-5.1,37-7.6,56.1-7.7c19,0.1,38.2,2.6,56.1,7.7   c42.8-29.7,61.5-23.5,61.5-23.5c12.2,31.6,4.5,55,2.2,60.8c14.3,16.1,23,36.6,23,61.6c0,88.2-52.4,107.6-102.3,113.3   c8,7.1,15.2,21.1,15.2,42.5c0,30.7-0.3,55.5-0.3,63c0,6.1,4,13.3,15.4,11C415.9,449.1,480,363.1,480,261.7   C480,134.8,379.7,32,256,32z"/>
</svg>

<span class="new-window"><svg  height="8px"  style="enable-background:new 0 0 1000 1000;" version="1.1" viewBox="0 0 1000 1000" width="8px" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" >
<path d="M598 128h298v298h-86v-152l-418 418-60-60 418-418h-152v-86zM810 810v-298h86v298c0 46-40 86-86 86h-596c-48 0-86-40-86-86v-596c0-46 38-86 86-86h298v86h-298v596h596z" style="fill-rule:evenodd;clip-rule:evenodd;fill:;"/>
</svg>
</span></a>



    </div>
  </div>
</nav>

    </div>
  </header>


    <main role="main">
      
  <article class="w-100 ph4 pb5 pb6-ns pt1 pt5-ns">
    <div class="order-0 w-20 dn db-l doc-menu" id="doc-menu">
      <div class="order-0 w-20 mt2 mb2" id="search-wrapper">
  <input id="search-box" type="search" placeholder="search" />
</div>

      
<nav role="navigation">
  <ul class="list pa0 nl2">
    
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".getting-started">入门（Getting Started）</a>
        <ul class="getting-started desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/getting-started.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/getting-started/what-you-need.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              准备工作（What You Need）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/getting-started/hello-world.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Hello World
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/getting-started/how-it-works.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              庖丁解牛
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".types">类型系统（Types）</a>
        <ul class="types desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/types.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/at-a-glance.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              类型系统概览
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/classes.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              类（Classes）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/primitives.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              基元类（Primitives）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/actors.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              并发单元（Actors）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/traits-and-interfaces.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              特征和接口（Traits and Interfaces）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/structs.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              结构体（Structs）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/type-aliases.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              类型别名（Type Aliases）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/types/type-expressions.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              类型表达式（Type Expressions）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2  primary-color" data-target=".expressions">表达式（Expressions）</a>
        <ul class="expressions desktopmenu animated fadeIn list pl0 bg-light-gray db">
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 primary-color ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/literals.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              字面量（Literals）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/variables.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              变量（Variables）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/ops.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              运算符（Operators）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/arithmetic.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              算术运算符（Arithmetic）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/control-structures.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              流程控制（Control Structures）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/methods.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              方法（Methods）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/errors.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              异常处理（Errors）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/equality.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              比较（Equality in Pony）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/sugar.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              语法糖（Sugar）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/object-literals.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              匿名对象（Object Literals）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/expressions/partial-application.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              柯里化（Partial Application）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".reference-capabilities">引用权能（Reference Capabilities）</a>
        <ul class="reference-capabilities desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/reference-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              引用权能（Reference Capabilities）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/guarantees.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能约束（Reference Capability Guarantees）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/consume-and-destructive-read.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能转让和破坏性读取（Consume and Destructive Read）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/recovering-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能借用（Recovering Capabilities）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/aliasing.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              别名引用（Aliasing）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/passing-and-sharing.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Passing and Sharing References
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/capability-subtyping.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能包含关系（Capability Subtyping）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/combining-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能合并（Combining Capabilities）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/arrow-types.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              箭头的用法（Arrow Types aka Viewpoints）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/reference-capabilities/capability-matrix.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              权能矩阵（Reference Capability Matrix）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".object-capabilities">对象权能模型（Object Capabilities）</a>
        <ul class="object-capabilities desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/object-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/object-capabilities/object-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              对象权能模型（Object Capabilities）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/object-capabilities/trust-boundary.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              边界信任（Trust Boundary）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".pattern-matching">模式匹配（Pattern Matching）</a>
        <ul class="pattern-matching desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/pattern-matching.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/pattern-matching/match.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              匹配表达式（Match Expressions）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/pattern-matching/as.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              as操作符（As Operator）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".generics">泛型（Generics）</a>
        <ul class="generics desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/generics.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/generics/generics-and-reference-capabilities.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              泛型和引用权能（Generics and Reference Capabilities）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/generics/generic-constraints.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              泛型约束（Constraints）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".packages">包（Packages）</a>
        <ul class="packages desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/packages.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/packages/package-system.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              包机制（Package System）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/packages/use-statement.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              包的使用方式（Use Statement）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/packages/standard-library.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              标准库（Standard Library）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".testing">测试（Testing）</a>
        <ul class="testing desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/testing.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/testing/ponytest.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Testing with Ponytest
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".c-ffi">C FFI</a>
        <ul class="c-ffi desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/c-ffi.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/c-ffi/calling-c.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Calling C from Pony
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/c-ffi/linking-c.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Linking to C Libraries
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/c-ffi/c-abi.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              C ABI
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/c-ffi/callbacks.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Callbacks
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".gotchas">陷阱（Gotchas）</a>
        <ul class="gotchas desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas/divide-by-zero.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Divide by Zero
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas/garbage-collection.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Garbage Collection
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas/scheduling.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Scheduling
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas/side-effect-ordering-in-function-call-expressions.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Function Call Side Effects
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/gotchas/recursion.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Recursion
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".where-next">下一步？（Where Next?）</a>
        <ul class="where-next desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/where-next.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
        </ul>
      </li>
      
      <li class="f5 w-100 hover-bg-light-gray hover-accent-color-light fw8">
        <a href="javascript:void(0)" class="js-toggle dib w-100 link mid-gray hover-accent-color-light pl2 pr2 pv2 " data-target=".appendices">附录（Appendices）</a>
        <ul class="appendices desktopmenu animated fadeIn list pl0 bg-light-gray dn">
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              概述（Overview）
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/ponypath.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              PONYPATH
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/lexicon.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Lexicon
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/symbol-lookup-cheatsheet.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Symbol Lookup Cheatsheet
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/keywords.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Keywords
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/examples.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Examples
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/whitespace.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Whitespace
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/compiler-args.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Compiler Arguments
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/memory-allocation.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Memory Allocation at Runtime
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/garbage-collection.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Garbage Collection with Pony-ORCA
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/platform-dependent-code.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Platform-dependent code
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/error-messages.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              A Short Guide to Pony Error Messages
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/annotations.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Program Annotations
            </a>
          </li>
          <li class="f6 fw4">
            <a href="/pony-tutorial/appendices/serialisation.html" class="db link hover-bg-gray hover-white pl3 pr2 pv2 black ">
              Serialisation
            </a>
          </li>
        </ul>
      </li>
  </ul>
</nav>

    </div>
    <div class="flex-l" id="the-body">
      <div class="order-1 w-60-l mw9 ph0 ph5-ns mid-gray nested-copy-line-height no-underline nested-links nested-img nested-copy-seperator nested-blockquote mt0-ns" style="flex-grow:1;">
        <div class="order-0 mt4 w-100 center mw7" style="clear: both;">
          <a id="doc-menu-toggle" class="icon icon-menu" href="javascript:void(0)" onClick="hideShowDM()"></a>
        </div>
        <div class="documentation-copy center mw7" id="content">
          <header class="mt4 w-100">
            <p class="f6 b helvetica tracked">
                
              表达式（EXPRESSIONS）
            </p>
            <h1 class="f1 athelas mb1">概述（Overview）</h1>
          </header>

          <main class="nested-copy-line-height lh-copy serif f4 nested-links nested-img mid-gray pr4-l"><!-- raw HTML omitted -->
<p>本章介绍Pony语言的各种表达方式。从变量到流程控制等内容。</p>





          </main>

    <section class="flex-ns flex-wrap justify-around mt5">
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/literals.html" class="link black dim">
        字面量（Literals）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>What do we want?
Values!
Where do we want them?
In our Pony programs!
Say no more
每一种编程语言都会有字面量对数据的类型进行描述，Pony也不例外。
Pony表达式中常用的字面量有：布尔、数值、字符、字符串、数组。
Bool型 布尔类型有两个可选值：true 和 false。
数字型 数字型字面量包括：有符号整数、无符号整数和浮点数。
在大多数情况下，Pony可以从上下文中推导出具体的数据类型（这包括，分配给字段或局部变量或作为方法/行为调用的参数）。
可以使用以下一种数字类型的构造函数来帮助编译器确定字面量的具体类型：
 U8, U16, U32, U64, U128, USize, ULong I8, I16, I32, I64, I128, ISize, ILong F32, F64  let my_explicit_unsigned: U32 = 42_000 let my_constructor_unsigned = U8(1) let my_constructor_float = F64(1.234) 整数可以以十进制，十六进制或二进制形式给出：
let my_decimal_int: I32 = 1024 //十进制 let my_hexadecimal_int: I32 = 0x400	//十六进制 let my_binary_int: I32 = 0b10000000000	//二进制 浮点文字以标准浮点或科学计数法表示：</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/variables.html" class="link black dim">
        变量（Variables）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>Pony和其他编程语言一样，可以使用变量存储数据。不同种类的变量有不同的生命周期和使用场景。
局部变量 Pony中的局部变量与其他语言类似，可以在执行计算时存储临时值。局部变量位于代码块中（它们是该代码块的 local ），并在每次进入代码块时自动创建，并在代码块结束时销毁。
定义局部变量，可以使用关键字var（也可以使用let，但是我们稍后再讲）。在var后面紧跟着的时变量的名称，变量名后面加上一个：可以设置（可选）变量的类型。例如：
var x: String = &quot;Hello&quot; var y = &quot;Hello&quot; 上面示例中，创建了一个字符串类型的变量x，并赋值为&quot;Hello&quot;。
定义变量时可以不用给变量赋初始值：可以稍后再赋值。但是如果使用没有赋值的变量，编译器会报一个变量还未初始化的错误： uninitialized variable 。
所有变量要指定类型，但是如果在声明时提供了初始值，就可以省略类型，编译器会根据初始值自动推导出变量的类型。
下面示例中x，y和z定义方式是等价的。
var x: String = &quot;Hello&quot; var y = &quot;Hello&quot; var z: String z = &quot;Hello&quot; 可以同时省略变量的类型和初始值吗？ 不行。这样的话编译器无法确定变量的类型。
所有局部变量名称均以小写字母开头。如果需要，可以用一个（或多个）引号'结尾，当您规避变量重名问题时，会很有用。例如，有一个名为time的变量，另一个变量名可以用time'。
变量所在的代码块称为 作用域（scope） 。作用域的范围取决于定义的位置。例如，在if语句的then表达式中定义的变量的作用域就是该then表达式。虽然我们还没有讲到if语句，不过它与其他种语言中的用法是相似的。
if a &gt; b then var x = &quot;a is bigger&quot; env.out.print(x) // OK end env.out.print(x) // Illegal 变量定义后仅在作用域结束前有效。对于变量x，它的有效范围是then表达式到结尾的的end之间：在那之后，就无法再使用它了。
var和let 局部变量用var或let声明。使用var表示这个变量可以反复赋值。使用let表示这个是常量只能赋值一次，无法被修改。
var x: U32 = 3 let y: U32 = 4 x = 5 // OK y = 6 // Error, y is let 使用let时必须初始化。</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/ops.html" class="link black dim">
        运算符（Operators）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>中缀运算符（Infix Operators） 中缀运算符需要两个操作数，位于操作数之间。算术和比较运算符是最常见的中缀运算符：
1 + 2 a &lt; b Pony的中缀运算符集和其他语言基本一致。
运算符别名（Operator aliasing） Pony中的大多数中缀运算符都是函数的别名。左边的操作数是调用函数的接收器，右边的操作数作为参数传递。例如，下面的两个表达式是等效的：
x + y x.add(y) +不是只能用于特性类型的特殊符号。任何类型都可以提供自己的add函数，然后可以根据需要对该类型使用+。
在定义自己的add函数时，对参数类型或返回类型没有限制。 +的右侧必须与参数类型匹配，并且+表达式将具有add函数返回的类型。
下面的代码是自定义+运算符的完整示例：
// Define a suitable type class Pair var _x: U32 = 0 var _y: U32 = 0 new create(x: U32, y: U32) =&gt; _x = x _y = y // Define a + function fun add(other: Pair): Pair =&gt; Pair(_x + other._x, _y + other._y) // Now let's use it class Foo fun foo() =&gt; var x = Pair(1, 2) var y = Pair(3, 4) var z = x + y 使用类型联合体或f界多态性可以在某种程度上重载中缀运算符，但这不在本教程的讨论范围之内。有关更多信息，请参考Pony标准库。</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/arithmetic.html" class="link black dim">
        算术运算符（Arithmetic）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>算术运算就是你在小学中学到的与数字有关的概念：加法，减法，乘法，除法等。小菜一碟。人人都知道这个东西。尽管如此，还是希望花点时间阅读下这一节教程，因为牵扯到计算机，魔鬼总是隐藏在细节中。
在基元类章节中介绍过，Pony中的数字类型是一种映射到机器码的特殊原语。整数类型和浮点类型都支持一组丰富的算术运算和位运算。中缀运算符，在数字基元类型上作为普通函数实现。
Pony语言专注于两个目标，性能和安全性。这两个目标有时会发生冲突。对于整数和浮点数的算术尤其如此。为了确保代码安全，应在每个可能发生计算操的作上检查溢出，被零除和其他错误情况。 Pony尝试在编译时强制执行尽可能多的安全性检查，但是对算术运算的检查只能在运行时进行。另一方面，从代码的性能角度考虑，应尽快的执行整数算术运算，并在尽可能少的CPU周期内执行完毕。检查溢出是昂贵的，导致溢出的简单危险算术是廉价的。
Pony提供了不同的算术运算方式，使程序员可以自由选择最适合他们的操作：安全但较慢的操作或不太安全但快速的操作，因为性能对于某些应用场景至关重要。
整数（Integers） 默认的算术运算符（Ponys default Arithmetic） 在处理整数的+, -, *, /算术运算上，Pony使用了一些技巧，试图平衡对性能和正确性的需求。所有默认的算术运算都不会暴露任何未定义的行为或错误条件。这意味着它可以处理上溢/下溢和零除的情况。上溢/下溢使用对带符号整数的补全来适当地环绕语义来处理。在这方面，我们得到如下行为：
// unsigned wrap-around on overflow U32.max_value() + 1 == 0 // signed wrap-around on overflow/underflow I32.min_value() - 1 == I32.max_value() 除零是一种特殊情况，它会影响除法运算符/和取余%运算符。在数学中，零除是不确定的。为了避免将除法定义为部分除法，在除数为零时引发错误或在这种情况下引入未定义的行为，当除数为0时，将 normal 除法定义为0。如果不小心使用，可能会导致无提示错误。选择部分和校验的算术以除以零。
与[Unsafe Arithmetic](#非安全的算术运算符（Unsafe Arithmetic）) 相比，默认算法具有一点点运行时开销，因为它与unsafe变体不同，它会检测并处理溢出和除零的情况。
    Operator Method Description     + add() wrap around on over-/underflow   - sub() wrap around on over-/underflow   * mul() wrap around on over-/underflow   / div() x / 0 = 0   % rem() x % 0 = 0   %% mod() x %% 0 = 0   - neg() wrap around on over-/underflow   &gt;&gt; shr() filled with zeros, so x &gt;&gt; 1 == x/2 is true   &lt;&lt; shl() filled with zeros, so x &lt;&lt; 1 == x*2 is true     非安全的算术运算符（Unsafe Arithmetic） 不安全的整数算术接近于C语言中的整数算术所期望的结果。不做任何检查， raw speed ，上溢，下溢或被零除的可能性。像在C中一样，上溢，下溢和被零除的情况是不确定的。在这些情况下，请勿依赖结果。它可以是任何东西，并且高度特定于平台。被零除甚至可能会用SIGFPE使程序崩溃。我们的建议是仅在确保可以排除这些情况时才使用这些运算符。</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/control-structures.html" class="link black dim">
        流程控制（Control Structures）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>在程序开发过程中，你需要能够对条件做出判断，对集合进行遍历，或者重复执行一些逻辑。因此，流程控制必不可少。Pony具有你在其他语言中所熟悉的流程控制控制，例如if，while和for，但是在Pony中，它们的工作方式略有不同。
条件判断（Conditionals） if是最简单的流程控制控制。它仅在条件为真时才允许您执行某些操作。在Pony中的用法：
if a &gt; b then env.out.print(&quot;a is bigger&quot;) end 可以像在C语言中那样使用整数和指针作为条件吗？ 不行。在Pony中，if条件必须是布尔类型，即条件的返回值值始终为true或false。如果要判断数字a是否不为0，则需要明确的使用a！= 0。这个限制让Pony程序避免了潜在的类型错误。
需要在条件失败时的执行一些逻辑，只需添加一个else：
if a &gt; b then env.out.print(&quot;a is bigger&quot;) else env.out.print(&quot;a is not bigger&quot;) end 通常，您想要检测和处理多种条件，可以嵌套if语句，但这有点丑陋：
if a == b then env.out.print(&quot;they are the same&quot;) else if a &gt; b then env.out.print(&quot;a is bigger&quot;) else env.out.print(&quot;b bigger&quot;) end end 作为替代方案，Pony提供了结合了else和if的elseif关键字。这与其他语言中else if相同，并且每个if可以有任意数量的elseif：
if a == b then env.out.print(&quot;they are the same&quot;) elseif a &gt; b then env.</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/methods.html" class="link black dim">
        方法（Methods）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>在Pony中，所有的执行逻辑（代码）都被放在方法中。方法有三种：函数、构造函数和行为。所有的方法都要写在类型定义中（例如：类、基元类、actor等），不存在全局函数或全局行为。
行为用于处理发送给参与者的异步消息，我们在类型系统章节中已经讲解过行为。
可以像Python那样在任何方法之外添加一些代码吗？ 不行。所有的Pony代码都必须在一个方法中。
函数（Functions） Pony的函数与其他语言中的函数（或方法）非常相似。它们可以具有0个或多个参数，以及0个或1个返回值（如果需要像Go语言的多返回值可以使用元组）。如果省略了返回类型，则该函数的返回值将为None。
class C fun add(x: U32, y: U32): U32 =&gt; x + y fun nop() =&gt; add(1, 2) // Pointless, we ignore the result 函数参数（如果有）在函数名称后的括号中指定。即便没有任何参数的函数定义时，括号也不能省略。
每个参数都有一个名称和类型。在我们的示例函数中，add函数有两个参数x和y，它们都是U32类型。传递给函数调用的值（示例中为1和 2）称为实参（arguments），并且在进行调用时会对其求值并分配给形参（parameters）。形参虽然没有明确给出声明的方式，但实际上它们被声明为let。
形参后面的的是返回类型。如果不需要返回值，可以省略。
返回值后面是=&gt;，最后是函数体。返回值是函数体表达式的执行结果（请记住，所有内容都是表达式），也就是函数中最后一条表达式的值。
如果想从函数中提前返回，可以使用return表达式。如果函数具有返回类型，需要为return提供一个值。如果该函数没有返回类型，单独用return就行。
可以按参数类型重载函数吗？ 不行，同一个类型中不允许出现重名的方法。
构造函数（Constructors） 跟其他语言一样，Pony的构造函数也是用于初始化对象。不同的是，Pony构造函数可以自定义函数名字，也可以使用任意数量和类型的参数。Pony的默认构造函数（所有的类型定义都一样）为create。
class Foo var _x: U32 new create() =&gt; _x = 0 new from_int(x: U32) =&gt; _x = x 构造函数的作用，是为了在创建对象时初始化对象内部状态。Pony中构造函数必须对所有字段做出初始化。
可以从构造函数中提前返回吗？ 是的。使用不带值的return命令。但是要确保return前所有字段都已经进行了初始化。
方法调用（Calling） 方法的调用与其他语言一样，通过在方法名称后的括号内提供参数来调用。即使没有参数需要传递，也需要括号。
class Foo fun hello(name: String): String =&gt; &quot;hello &quot; + name fun f() =&gt; let a = hello(&quot;Fred&quot;) 要实例化一个类型，需要调用这个类型的构造函数。指定类型，后跟一个点，然后是要调用的构造函数名：</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/errors.html" class="link black dim">
        异常处理（Errors）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>你可能熟悉Python、Ruby、Java、C++等语言中的异常处理方式，Pony中有所不同，Pony提供了一个更简单的机制来帮助处理异常。Pony触发异常的方式与其他语言有一些重要的语义区别，Pony用error（还有as）关键字和偏函数(Partial functions)来触发异常。让我们看看Pony是如何处理异常的，然后和你习惯的语言对比一下有什么不同。
异常的触发和处理(Raising and handling errors) 使用error可以触发一个异常。可以任何时候都可以使用error。此时后续代码会停止执行，调用链被解除，逻辑跳寻找并转到异常处理代码块中继续执行。异常处理机制是在编译时会进行检查，确保在运行时不会导致整个程序崩溃。
异常处理程序是使用try-else语法声明的。
try callA() if not callB() then error end callC() else callD() end 在上面的代码中，callA()总是会被执行，callB()也会被执行。如果callB()的返回值为true，那么我们将按照正常方式继续执行callC()，那么callD()将不会被执行。
但是，如果callB()返回false，则会触发一个异常。此时，执行将停止，寻找并执行最近的异常处理程序。在本例中，else中的callD()将被执行。
在这两种情况下，程序都将继续执行try end后面的逻辑。
必须提供一个异常处理程序吗? 不需要。try可以单独工作。如果不提供else，则不会执行任何异常处理操作,直接转转到try表达式之后继续执行。
如果有一些可能会触发异常的逻辑，但你不需要在发生后做出处理(比如:一个文件存在的话就读取它的内容)，可以把这段逻辑里面放在一个try中,不需要提供else。
try // Do something that may raise an error end __异常处理逻辑中需要做些什么? __ 无所谓。如果您提供了一个异常处理程序，那么它必须包含一些代码，具体执行些什么逻辑取决于你自己。
一个try代码块的返回值是什么?try的返回值是try的最后一个表达式的值，如果出现过程中出现了异常，就使用else子句中的最后一个表达式的值。如果出现了一个异常，并且没有提供else子句，那么返回值将是None。
偏函数(Partial functions) Pony并不要求像前面的例子那样立即处理所有的异常。函数执行时可能触发异常，而这些异常可以由调用它们的代码处理。这些被称为偏函数(Partial functions)(这是一个数学术语，意思是对于所有可能的输入(即参数)没有定义返回值的函数)。偏函数必须在函数签名(定义返回类型)之后和调用位置(右括号之后)加上?。
下面示例，如果输入为负数，那么接受有符号整数的阶乘函数就会出错。这个函数只在有效的输入时才会正确执行。
fun factorial(x: I32): I32 ? =&gt; if x &lt; 0 then error end if x == 0 then 1 else x * factorial(x - 1)?</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/equality.html" class="link black dim">
        比较（Equality in Pony）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>Pony有两种形式的平等:结构平等和身份平等。
类型比较（Identity equality） Pony中的类型检查是通过is关键字来完成的。is可以判断两个类型是否相同。
if None is None then // TRUE! // There is only 1 None so the identity is the same end let a = Foo(&quot;hi&quot;) let b = Foo(&quot;hi&quot;) if a is b then // NOPE. THIS IS FALSE end let c = a if a is c then // YUP! TRUE! end 结构化比较（Structural equality） Pony的结构化比较是通过中缀运算符==来完成的。它可以判断同的数据是否具有相同的值。如果被比较结果为true，可以认为它们具有相同的值。
可以通过实现fun eq(that: box-&gt;Foo): Bool来自定义对比逻辑。注意，因为==是一个中缀操作符，eq必须定义在左边的操作数上，而右边的操作数必须是Foo类型。
class Foo let _a: String new create(a: String) =&gt; _a = a fun eq(that: box-&gt;Foo): Bool =&gt; this.</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/sugar.html" class="link black dim">
        语法糖（Sugar）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>Pony允许你编写代码时做一些简化，让代码更简洁、易读。使用语法糖是可选的，如果您愿意，你可以始终使用完整的书写方式。
Apply语法糖 许多Pony类都有一个名为apply的函数，该函数可以执行一些该类型最常见的操作。Pony允许你省略apply这个函数名，直接从对象调用。所以:
var foo = Foo.create() foo() 等同于：
var foo = Foo.create() foo.apply() 需要参数的话可以像调用普通方法那样去添加。
var foo = Foo.create() foo(x, 37 where crash = false) 等同于：
var foo = Foo.create() foo.apply(x, 37 where crash = false) 必须要提供参数吗? 是的，只有apply会为你自动添加，正确的参数数量和类型必须你自己提供。默认传参和命名传参的机制可以正常使用。
如果apply会被自动添加，那我怎么调用其他函数？ 只有直接调用对象时才添加apply，其他时候不会。编译器能判断什么时候该添加apply。
Create语法糖 要实例化对象，你需要指定类型并调用构造函数。Pony允许你忽略构造函数，并将为您插入一个create()调用。所以:
var foo = Foo 等同于：
var foo = Foo.create() 通常，类型在表达式中是不被求值的，因此省略掉构造函数并不会造成歧义。记住，类型是很容易被识别的，因为它始终是以大写字母开头。
如果create需要参数，可以直接在后面加括号传入。默认参数和命名传参机制都可以正常使用。
var foo = Foo(x, 37 where crash = false) 等同于：
var foo = Foo.create(x, 37 where crash = false) 如果我想使用一个名字不是create的构造函数怎么做?</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/object-literals.html" class="link black dim">
        匿名对象（Object Literals）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>有时候，能够内联地写一个完整的对象是非常方便的。在Pony中，这被称为匿名对象，它做的事情和JavaScript中的匿名对象差不多：它可以生成一个可以立即使用的对象。
但是Pony是静态类型的，所以一个匿名对象也会创建一个匿名类，这个匿名对象会满足这个匿名类。这类似于Java和C#中的匿名类。在Pony中，匿名类型可以提供任意数量的特征和接口。
匿名类和匿名对象是什么？（What&rsquo;s this look like, then?） 匿名类表达式与类（class）的定义基本相同，object表达式构建了一个匿名类并返回它的的实例，这个实例被称为匿名对象。匿名类和普通类有一些细微的区别，下面是一个简单的例子:
object fun apply(): String =&gt; &quot;hi&quot; end 很简单明了。让我们对其进行扩展，提供一个Hashable特征的实现，以便编译器能够确保匿名类型满足该接口。也可以用相同的方法来提供其他特征。
object is Hashable fun apply(): String =&gt; &quot;hi&quot; fun hash(): USize =&gt; this().hash() end 我们不能给匿名对象指定构造函数，因为它本身 就是 一个构造函数。那么我们如何分配字段呢？直接声明就行了。例如:
use &quot;collections&quot; class Foo fun foo(str: String): Hashable =&gt; object is Hashable let s: String = str fun apply(): String =&gt; s fun hash(): USize =&gt; s.hash() end 在匿名对象所在的作用域中声明和初始化局部变量，等同于在类的构造函数中定义和初始化字段， 匿名类的所有的成员汉书都可以 捕获（capturing） 这些变量当做字段去实用。这非常有趣！它让我们有任意复杂的可以有多个入口点(例如，你可以在一个闭包上调用函数)的。
默认情况下，带有字段的匿名对象将以ref（引用权能的一种权限类型）方式返回，除非你通过在object关键字后显示的指定一个引用权能的类型来声明权限。例如，一个带有sendable权限的对象可以在需要时可以声明为iso:
use &quot;collections&quot; class Foo fun foo(str: String): Hashable iso^ =&gt; object iso is Hashable let s: String = str fun apply(): String =&gt; s fun hash(): USize =&gt; s.</p>
      
    </div>
  </div>
</div>
</div>
      
        <div class="relative w-100 mb4 bg-white"><div class="relative w-100 mb4 bg-white nested-copy-line-height">
  <div class="bg-white mb3 pa4 gray overflow-hidden">
    <h1 class="f3 near-black">
      <a href="/pony-tutorial/expressions/partial-application.html" class="link black dim">
        柯里化（Partial Application）
      </a>
    </h1>
    <div class="nested-links f5 lh-copy nested-copy-line-height">
      
        <p>柯里化（Partial Application）允许我们对构造函数、函数或行为设置 部分 参数，然后返回一个新函数，以便后面再填充其余的参数。
一个简单的例子 这里有一个简单的例子，创建一个回调函数。例如:
class Foo var _f: F64 = 0 fun ref addmul(add: F64, mul: F64): F64 =&gt; _f = (_f + add) * mul class Bar fun apply() =&gt; let foo: Foo = Foo let f = foo~addmul(3) f(4) 这是一个有点傻的示例，但希望，思路是清楚的。我们在foo上柯里化了addmul函数，把接收者绑定到foo上，把add参数绑定为3。我们得到一个返回值它是一个匿名对象：f，它有一个apply方法，接受一个mul参数。当它被调用时，它执行foo.addmul (3,mul)。
我们也可以绑定所有的参数：
let f = foo~addmul(3, 4) f() 也不提绑定任何实参：
let f = foo~addmul() f(3, 4) 命名传参（之前讲过的无序传参方式） 命名传参的方式允许柯里化（Partial Application）以任意顺序绑定参数，而不只是从左到右。例如:
let f = foo~addmul(where mul = 4) f(3) 在这里，我们绑定了mul参数，但未绑定add。</p>
      
    </div>
  </div>
</div>
</div>
      
    </section>
        </div>
        <div id="search-results" class="center mw7 dn"></div>
      </div>
    </div>
  </article>

    </main>
    

<script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/highlight.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/languages/pony.min.js"></script>
<script>hljs.initHighlightingOnLoad();</script>

<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lunr.js/2.3.5/lunr.min.js"></script>

<script async defer src="https://buttons.github.io/buttons.js"></script>

<script>
  var toggleBtns = document.getElementsByClassName('js-toggle')
  for (var i = 0; i < toggleBtns.length; i++) {
    toggleBtns[i].addEventListener('click', toggleClass, false)
  }

  var myToggleBtns = document.getElementsByClassName('hide-show-toggle')
  for (var i = 0; i < myToggleBtns.length; i++) {
    myToggleBtns[i].addEventListener('click', hideShow, false)
  }

function hideShowDM() {
  var menu = document.getElementById("doc-menu")
  var thebody = document.getElementById("the-body")
  if (window.getComputedStyle(menu).display == "none") {
    menu.style.display = "block";
    thebody.style.left = "300px";
  } else {
    menu.style.display = "none";
    thebody.style.left = "0px";
  }
}

function hideShowCM() {
  var menu = document.getElementById("context-menu")
  if (window.getComputedStyle(menu).display == "none") {
    menu.style.display = "block";
  } else {
    menu.style.display = "none";
  }
}

function toggleClass() {
  
  var content = this.dataset.target.split(' ')
  
  var mobileCurrentlyOpen = document.querySelector('.mobilemenu:not(.dn)')
  var desktopCurrentlyOpen = document.querySelector('.desktopmenu:not(.dn)')
  var desktopActive = document.querySelector('.desktopmenu:not(.dn)')

  
  for (var i = 0; i < content.length; i++) {
    var matches = document.querySelectorAll(content[i]);
    
    [].forEach.call(matches, function(dom) {
        dom.classList.contains('dn') ?
        dom.classList.remove('dn') :
        dom.classList.add('dn');
         return false;
       });
        
      if (mobileCurrentlyOpen) mobileCurrentlyOpen.classList.add('dn')
      if (desktopCurrentlyOpen) desktopCurrentlyOpen.classList.add('dn')
      if (desktopActive) desktopActive.classList.remove('db')

    }
  }

var Pony = {};


Pony.Search = (function() {
  var that = {}
  that.lunrIndex = undefined;
  that.pages = [];

  that.doSearch = function(query) {
    var resultsContainer = $('#search-results');
    var contentContainer = $('#content');
    
    var results = this.lunrIndex.search(query).map(function(result) {
      
        return {
            page: that.pages[result.ref],
            metadata: result.matchData.metadata
        };
    });

    
    resultsContainer.empty();
    resultsContainer.append(
        $("<header>", {class: "mt4 w-100"}).append(
            $("<p>", {class: "f6 b helvetica tracked", text: "SEARCH RESULTS"}))
    );
    var resList = $("<ul>", {id: "search-result-list"});

    
    results.slice(0, 100).forEach(function(result) {
        var res = $("<li>");
        var div = $("<div>", {class: "search-result"});
        div.append($("<a>", {
          href: result.page.uri,
          text: result.page.title,
          class: "search-result-title"
        }));
        var p = $("<p>", {
            class: "search-result-summary"
        });
        var highlighted = that.highlightResult(result.page.summary, result.metadata);
        p.append(highlighted);
        div.append(p);
        res.append(div);
        resList.append(res);
    });
    resultsContainer.append(resList);

    
    contentContainer.addClass("dn");
    resultsContainer.removeClass("dn");
  };

  that.highlightResult = function(text, metadata) {
      var span = $("<span>");
      for (var key in metadata) {
        var summary_metadata = metadata[key]["summary"];
        if (summary_metadata !== undefined && summary_metadata["position"] !== undefined) {
            var position_metadata = summary_metadata["position"];
            var last_pos = 0;
            summary_metadata["position"].forEach(function(elem) {
                span.append(
                    $("<span>", {text: text.slice(last_pos, elem[0])})
                );
                span.append(
                    $("<span>", {
                        class: "highlighted",
                        text: text.slice(elem[0], elem[0] + elem[1])})
                );
                last_pos = elem[0] + elem[1];
            });
            span.append(
                $("<span>", {text: text.slice(last_pos, text.length)})
            );
        } else {
          span.text(text);
        }
      }
      return span;
  };

  that.initLunr = function(onSuccess) {
      $.getJSON("/index.json")
        .done(function(index) {
           
           that.pages = index;
           that.lunrIndex = lunr(function() {
             this.metadataWhitelist = ['position']; 
             this.field("title", { boost: 10 });
             this.field("tags", { boost: 5 });
             this.field("categories", { boost: 5 });
             this.field("content");
             this.field("summary", {boost: 0});
             this.ref("i");

             index.forEach(function (page, idx) {
                 page["i"] = idx;
                 this.add(page)
               },
               this
             );
           });
           onSuccess();
        })
        .fail(function(jqxhr, textStatus, error) {
          var err = textStatus + ", " + error;
          console.error("Error getting search index file:", err);
        });
    }
  that.setUpSearchUI = function() {
    $('#search-box').keyup(function() {
        var query = $(this).val();
        if (query.length < 2) {
            if (query.length == 0) {
                $('#content').removeClass('dn');
                $('#search-results').empty().addClass('dn');
            }
            return;
        }
        if (that.lunrIndex === undefined) {
            that.initLunr(function () {
              that.doSearch(query);
            });
        } else {
            that.doSearch(query);
        }
    });
  }
  return that;
})();




$(document).ready(function() {
  Pony.Search.setUpSearchUI();
});
</script>

  </body>
</html>
